fn main() {
    foo4();
}

// fn foo1() {
//     let mut arr = vec![1, 2, 3]; // 获得一份只读引用
//     let last = arr.last(); //从arr获取到了最后一个数值,last是只读借用
//     arr.push(4); // 这里，扩容可能会创建一个可变借用(两种引用存在发生了互斥)
//                  // arr 既可变又只读了
//     println!("last: {:?}", last);
// }

// 理解思路除了从所有权的存在情况分析外，还可以从内存的角度分析
// 首先获得一份vec的引用arr，然后再通过这个引用获取last元素，
// 但是，随后立刻从vec中加入一个元素，这个时候可能导致扩容，则原本的vec引用arr会重新分配内存
// 导致了last变得无效,可能指向了一块空的内存,出现未定义.

// 如果是要获取到最后一个元素,则应该先把last元素copy出来,再对原数组扩容,
// 此时copy出来的值已经对原本的引用没有影响了
#[allow(dead_code)]
fn foo2() {
    let mut arr = vec![1, 2, 3]; // 获得一份只读引用
    let last = arr.last(); //从arr获取到了最后一个数值,last是只读借用
    println!("last: {:?}", last);
    arr.push(4); // 到了这里,只读借用已经不在使用,非活跃
}

#[allow(dead_code)]
fn foo3() {
    let mut arr = vec![1, 2, 3]; // 获得一份只读引用
    let last = arr[arr.len() - 1]; //从arr获取到了最后一个数值(copy)
    arr.push(4); // 到了这里,只读借用已经不在使用,非活跃
    println!("last: {:?}", last);
}

use std::sync::Arc;
#[allow(dead_code)]
fn foo4() {
    // let arr = vec![1]; // 一个只读借用,不能够跨线程
    // 线程借用的arr生命周期可能会长于main函数中的arr，
    // 简单处理的话把main中arr的所有权move到线程里即可，
    // 线程的运行时间可能会比当前函数还要长，而闭包中又借用了arr，使用move将当前函数的arr所有权转移给线程。
    let arr = Arc::new(vec![1]);
    let arr1 = arr.clone();
    let handler = std::thread::spawn(move || {
        println!("线程: {:?}", arr1);
    });
    println!("main: {:?}", arr);
    handler.join().unwrap();
}
